The R `rgcapi` library

Algorithmic trading has always been a fascination for me. The abundance of time-series data, coupled with the challenge of developing and testing trading strategies, makes it an exciting space. Forex markets provided one of the most accessible playgrounds for such experimentation.

When I decided to create an interface for the Gain Capital API (the backend for Forex.com), I made a deliberate choice to use R over Python. Why? Partly for the joy of experimenting with R6 classes, an encapsulated, object-oriented paradigm in R. It felt like the right opportunity to learn and build something modular, reusable, and maintainable—all characteristics R6 is known for.

This journey led to the creation of rgcapi, an R package that connects directly to the Gain Capital API. Below, I’ll walk you through its features, how to set it up, and how you can use it to unlock algorithmic trading capabilities in R.

What is `rgcapi`?

rgcapi is an R package that provides a comprehensive interface to Gain Capital’s API (V1 and V2). It allows you to:

Manage trading accounts and monitor balances.
Retrieve real-time market data.
Automate trade execution and management.
Extract historical data for analysis and backtesting.

The package is built using R6, which makes it modular, stateful, and efficient for iterative workflows. Notably, rgcapi is the only package in the R ecosystem to offer connectivity to the Gain Capital API, making it a unique and valuable tool for R users.

Key Features of `rgcapi`

Account Management: Easily initialize sessions and manage user accounts.
Market Information: Retrieve real-time market quotes, instrument details, and other key data.
Trading Operations: Execute trades, manage orders, and monitor open positions.
Historical Data: Extract price data for backtesting and time-series analysis.

Installation

You can install rgcapi directly from GitHub. Start by installing the devtools package if you don’t already have it.

# Install devtools if needed
install.packages("devtools")

# Install rgcapi from GitHub
devtools::install_github("athammad/rgcapi")

Setting Up Your API Credentials

To access the API, you’ll need credentials from Forex.com, including a username, password, and application key. Once you have them, initialize the client like this:

library(rgcapi)

# Replace with your actual credentials
IDLOG <- "your_username"
PSWD <- "your_password"
APKEY <- "your_appkey"

# Initialize the client for Gain Capital API V2
client <- GCapiClientV2$new(username = IDLOG, password = PSWD, appkey = APKEY)

Example Workflows: Exploring rgcapi in Action

Here’s where the magic happens. Below, I’ll walk you through practical use cases, showing how you can leverage rgcapi to perform key trading operations.

1. Retrieve Account Information

The first step in any trading workflow is understanding your account status. With rgcapi, you can fetch account details in seconds:

account_info <- client$get_account_info()
print(account_info)

2. Fetch Market Information

Market data is the backbone of trading strategies. With rgcapi, you can access detailed information about instruments:


# Get market information for EUR/USD
market_info <- client$get_market_info("EUR/USD")
print(market_info)

# Retrieve specific fields, such as MarketId and Name
market_id <- client$get_market_info("EUR/USD", get = "MarketId")
market_name <- client$get_market_info("EUR/USD", get = "Name")
print(market_id)
print(market_name)

3. Extract Historical Price Data

Historical data is critical for backtesting strategies. With rgcapi, you can retrieve precise price information:

# Get latest price data
fromA <- as.integer(as.POSIXct(Sys.Date(), tz = "UTC") - months(1))
toB <- as.integer(as.POSIXct(Sys.time(), tz = "UTC"))
prices <- client$get_prices(
  market_id = market_id,
  num_ticks = 1,
  from_ts = fromA,
  to_ts = toB,
  price_type = "MID"
)
print(prices)

For OHLC (Open, High, Low, Close) data, adjust the parameters:

# Retrieve OHLC data for the last 24 hours
fromA <- as.integer(as.POSIXct(Sys.Date(), tz = "UTC") - days(1))
toB <- as.integer(as.POSIXct(Sys.time(), tz = "UTC"))
ohlc <- client$get_ohlc(
  market_id = market_id,
  num_ticks = 4000,
  interval = "MINUTE",
  span = 30,
  from_ts = fromA,
  to_ts = toB
)
print(ohlc)

4. Execute a Trade

Once you’ve analyzed the market, placing trades is seamless. Here’s how to place a buy order:

# Place a buy trade
trade_resp <- client$trade_order(
  quantity = 1020,
  offer_price = prices$Price,
  direction = "buy",
  trading_acc_id = client$trading_account_id,
  market_id = market_id,
  market_name = market_name,
  stop_loss = 1.060000,
  take_profit = 1.080000,
  tolerance = 0.0005
)
print(trade_resp)

5. Monitor and Manage

Keeping track of active trades is essential for managing risk. Here’s how to list open positions:

# List all open positions
open_positions <- client$list_open_positions()
print(open_positions)

Closing a position is equally straightforward:

# Close a trade order
close_resp <- client$trade_order(
  quantity = 1020,
  offer_price = prices$Price,
  direction = "sell",
  trading_acc_id = client$trading_account_id,
  market_id = market_id,
  market_name = market_name,
  close = TRUE,
  order_id = open_positions$OrderId[1]
)
print(close_resp)

6. Retrieve Trade History

Understanding past trades can inform future strategies. Use the following code to retrieve your trade history:

# Get trade history
trade_history <- client$get_trade_history()
print(trade_history)

For me, developing rgcapi was both a practical solution and a creative experiment. It merges the analytical power of R with the dynamic world of Forex trading, offering a unique tool for data scientists and traders alike. Whether you’re building automated trading systems or simply exploring the markets, rgcapi is designed to make the process seamless and efficient.

Explore it on GitHub: athammad/rgcapi. I’d love to hear how you’re using it and what features you’d like to see next!

What is rgcapi?

Key Features of rgcapi